package com.wmwj.hxlj.service.impl;

import com.wmwj.hxlj.entity.Tag;
import com.wmwj.hxlj.entity.vo.PageResult;
import com.wmwj.hxlj.mapper.TagMapper;
import com.wmwj.hxlj.service.TagService;
import com.wmwj.hxlj.service.UserService;
import com.wmwj.hxlj.utils.Result;
import io.micrometer.common.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
@Service
public class TagServiceImpl implements TagService {
    // 自动注入TagMapper接口的实现类，用于操作标签数据
    @Autowired
    private TagMapper tagMapper;
    @Autowired
    private UserService userService;

    /**
     * 获取所有启用的标签
     *
     * @return 启用的标签列表
     */
    @Override
    public List<Tag> getAllEnabledTags() {
        return tagMapper.findAllEnabled();
    }

    /**
     * 分页查询标签
     *
     * @param page     页码，从1开始
     * @param size     每页大小
     * @param keyword  查询关键词，用于模糊匹配标签名称和ID
     * @return 包含分页信息和标签列表的分页结果对象
     */
    @Override
    public Result<PageResult> getTags(Integer page, Integer size, String keyword) {
        // 计算分页起始位置
        int pageStart = (page - 1) * size;

        // 查询数据
        List<Tag> tags = tagMapper.selectByPage(keyword, pageStart, size);

        // 查询总数
        long total = tagMapper.countByPage(keyword);


        return Result.success(new PageResult(tags, total));
    }

    /**
     * 获取使用最多的标签
     *
     * @param limit 限制获取标签的数量
     * @return 使用最多的标签列表
     */
    @Override
    public List<Tag> getMostUsedTags(int limit) {
        return tagMapper.findMostUsedTags(limit);
    }

    /**
     * 添加新标签
     *
     * @param tag 待添加的标签对象
     * @return 添加结果，包括成功或错误信息
     */
    @Override
    @Transactional
    public Result<Tag> addTag(Tag tag) {
        if(StringUtils.isBlank(tag.getName())){
            throw new RuntimeException("标签名称不能为空");
        }

        if(tagMapper.findByName(tag.getName()) != null){
            throw new RuntimeException("标签已存在");
        }

        // 设置标签的创建时间和更新时间为当前时间，状态为启用，初始使用次数为0
        tag.setCreateTime(new Date());
        tag.setUpdateTime(new Date());
        tag.setStatus(tag.getStatus());
        tag.setUseCount(0); // 初始使用次数为0
        // 插入标签数据到数据库
        int row = tagMapper.insert(tag);
        if(row == 0){
            return Result.error("添加失败");
        }else{
            return Result.success("添加成功", tag);
        }
    }

    /**
     * 删除指定名称的标签
     *
     * @param id 待删除的标签名称
     * @return 删除结果，包括成功或错误信息
     */
    @Override
    @Transactional
    public Result<String> deleteTag(Long id) {
        // 通过标签名称删除标签数据
        int row = tagMapper.deleteById(id);
        if(row == 0){
            return Result.error("删除失败");
        }else{
            return Result.success("删除成功");
        }
    }

    /**
     * 更新标签
     *
     * @return 更新结果，true表示成功，false表示失败
     */
    @Override
    public Result<Tag> updateTag(Tag tag) {
        if(StringUtils.isBlank(tag.getName())){
            throw new RuntimeException("标签名称不能为空");
        }

        // 先获取原标签信息
        try{
            Tag originalTag = tagMapper.findById(tag.getId());
            // 只有当名称被修改时才检查是否重复
            if(!originalTag.getName().equals(tag.getName()) &&
                    tagMapper.findByName(tag.getName()) != null){
                throw new RuntimeException("标签已存在");
            }
        }
        catch (Exception e){
            throw new RuntimeException("标签不存在");
        }




        tag.setUpdateTime(new Date());

        if(tagMapper.update(tag) == 0){
            return Result.error("更新失败");
        }else{
            return Result.success("更新成功", tag);
        }
    }

    /**
     * 批量增加标签的使用次数
     *
     * @param names 标签名称数组
     * @return 更新结果，true表示成功，false表示失败
     */
    @Override
    @Transactional
    public boolean batchIncrementTagUseCount(String[] names) {
        // 批量更新标签的使用次数
        int row = tagMapper.batchIncrementUseCount(names);
        return row > 0;
    }

    /**
     * 批量减少标签的使用次数
     *
     * @param names 标签名称数组
     * @return 更新结果，true表示成功，false表示失败
     */
    @Override
    @Transactional
    public boolean batchDecrementTagUseCount(String[] names) {
        // 批量减少标签的使用次数
        int row = tagMapper.batchDecrementUseCount(names);
        return row > 0;
    }

    /**
     * 根据标签ID查找标签
     *
     * @param id 标签ID
     * @return 标签名称
     */
    @Override
    public String findByid(int id) {
        Tag tag = tagMapper.findById(id);
        return tag.getName();
    }

    /**
     * 根据标签名称查找标签
     *
     * @param name 标签名称
     * @return true表示存在，false表示不存在
     */
    @Override
    public boolean findByName(String name) {
        if(tagMapper.findByName(name) == null)
            return false;
        else
            return true;

    }


}
